home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / rdflib / sparql / bison / SPARQLEvaluate.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  17.1 KB  |  406 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import rdflib
  5. from rdflib.sparql import sparqlGraph, sparqlOperators, SPARQLError
  6. from rdflib.sparql.sparqlOperators import getValue
  7. from rdflib.sparql.graphPattern import BasicGraphPattern
  8. from rdflib.sparql.Unbound import Unbound
  9. from rdflib.sparql.Query import _variablesToArray, queryObject, SessionBNode
  10. from rdflib.Graph import ConjunctiveGraph, Graph, BackwardCompatGraph, ReadOnlyGraphAggregate
  11. from rdflib import URIRef, Variable, BNode, Literal, plugin, RDF
  12. from rdflib.store import Store
  13. from rdflib.Literal import XSDToPython
  14. from IRIRef import NamedGraph, RemoteGraph
  15. from GraphPattern import ParsedAlternativeGraphPattern, ParsedOptionalGraphPattern
  16. from Resource import *
  17. from Triples import ParsedConstrainedTriples
  18. from QName import *
  19. from PreProcessor import *
  20. from Expression import *
  21. from Util import ListRedirect
  22. from Operators import *
  23. from FunctionLibrary import *
  24. from SolutionModifier import ASCENDING_ORDER
  25. from Query import AskQuery, SelectQuery
  26. DEBUG = False
  27. BinaryOperatorMapping = {
  28.     LessThanOperator: 'sparqlOperators.lt(%s,%s)%s',
  29.     EqualityOperator: 'sparqlOperators.eq(%s,%s)%s',
  30.     NotEqualOperator: 'sparqlOperators.neq(%s,%s)%s',
  31.     LessThanOrEqualOperator: 'sparqlOperators.le(%s,%s)%s',
  32.     GreaterThanOperator: 'sparqlOperators.gt(%s,%s)%s',
  33.     GreaterThanOrEqualOperator: 'sparqlOperators.ge(%s,%s)%s' }
  34. UnaryOperatorMapping = {
  35.     LogicalNegation: 'not(%s)',
  36.     NumericNegative: '-(%s)' }
  37. CAMEL_CASE_BUILTINS = {
  38.     'isuri': 'sparqlOperators.isURI',
  39.     'isiri': 'sparqlOperators.isIRI',
  40.     'isblank': 'sparqlOperators.isBlank',
  41.     'isliteral': 'sparqlOperators.isLiteral' }
  42.  
  43. def convertTerm(term, queryProlog):
  44.     '''
  45.     Utility function  for converting parsed Triple components into Unbound 
  46.     '''
  47.     if isinstance(term, Variable):
  48.         return Unbound(term[1:])
  49.     if isinstance(term, BNode):
  50.         return term
  51.     if isinstance(term, QName):
  52.         if not term.prefix:
  53.             return URIRef(queryProlog.baseDeclaration + term.localname)
  54.         if term.prefix == '_':
  55.             import warnings
  56.             warnings.warn('The verbatim interpretation of explicit bnode identifiers is contrary to (current) DAWG stance', SyntaxWarning)
  57.             return SessionBNode(term.localname)
  58.         return URIRef(queryProlog.prefixBindings[term.prefix] + term.localname)
  59.     isinstance(term, QName)
  60.     if isinstance(term, QNamePrefix):
  61.         return URIRef(queryProlog.baseDeclaration + term)
  62.     if isinstance(term, ParsedString):
  63.         return Literal(term)
  64.     return term
  65.  
  66.  
  67. def unRollCollection(collection, queryProlog):
  68.     nestedComplexTerms = []
  69.     listStart = convertTerm(collection.identifier, queryProlog)
  70.     if not collection._list:
  71.         yield (listStart, RDF.rest, RDF.nil)
  72.     elif len(collection._list) == 1:
  73.         singleItem = collection._list[0]
  74.         if isinstance(singleItem, RDFTerm):
  75.             nestedComplexTerms.append(singleItem)
  76.             yield (listStart, RDF.first, convertTerm(singleItem.identifier, queryProlog))
  77.         else:
  78.             yield (listStart, RDF.first, convertTerm(singleItem, queryProlog))
  79.         yield (listStart, RDF.rest, RDF.nil)
  80.     else:
  81.         yield (listStart, RDF.first, collection._list[0].identifier)
  82.         prevLink = listStart
  83.         for colObj in collection._list[1:]:
  84.             linkNode = convertTerm(BNode(), queryProlog)
  85.             if isinstance(colObj, RDFTerm):
  86.                 nestedComplexTerms.append(colObj)
  87.                 yield (linkNode, RDF.first, convertTerm(colObj.identifier, queryProlog))
  88.             else:
  89.                 yield (linkNode, RDF.first, convertTerm(colObj, queryProlog))
  90.             yield (prevLink, RDF.rest, linkNode)
  91.             prevLink = linkNode
  92.         
  93.         yield (prevLink, RDF.rest, RDF.nil)
  94.     for additionalItem in nestedComplexTerms:
  95.         for item in unRollRDFTerm(additionalItem, queryProlog):
  96.             yield item
  97.         
  98.     
  99.  
  100.  
  101. def unRollRDFTerm(item, queryProlog):
  102.     nestedComplexTerms = []
  103.     for propVal in item.propVals:
  104.         for propObj in propVal.objects:
  105.             if isinstance(propObj, RDFTerm):
  106.                 nestedComplexTerms.append(propObj)
  107.                 yield (convertTerm(item.identifier, queryProlog), convertTerm(propVal.property, queryProlog), convertTerm(propObj.identifier, queryProlog))
  108.                 continue
  109.             yield (convertTerm(item.identifier, queryProlog), convertTerm(propVal.property, queryProlog), convertTerm(propObj, queryProlog))
  110.         
  111.     
  112.     if isinstance(item, ParsedCollection):
  113.         for rt in unRollCollection(item, queryProlog):
  114.             yield rt
  115.         
  116.     
  117.     for additionalItem in nestedComplexTerms:
  118.         for item in unRollRDFTerm(additionalItem, queryProlog):
  119.             yield item
  120.         
  121.     
  122.  
  123.  
  124. def unRollTripleItems(items, queryProlog):
  125.     '''
  126.     Takes a list of Triples (nested lists or ParsedConstrainedTriples)
  127.     and (recursively) returns a generator over all the contained triple patterns
  128.     '''
  129.     if isinstance(items, RDFTerm):
  130.         for item in unRollRDFTerm(items, queryProlog):
  131.             yield item
  132.         
  133.     else:
  134.         for item in items:
  135.             if isinstance(item, RDFTerm):
  136.                 for i in unRollRDFTerm(item, queryProlog):
  137.                     yield i
  138.                 
  139.             for i in unRollTripleItems(item, queryProlog):
  140.                 yield item
  141.             
  142.         
  143.  
  144.  
  145. def mapToOperator(expr, prolog, combinationArg = None):
  146.     '''
  147.     Reduces certain expressions (operator expressions, function calls, terms, and combinator expressions)
  148.     into strings of their Python equivalent
  149.     '''
  150.     if not combinationArg or '(%s)' % combinationArg:
  151.         pass
  152.     combinationInvokation = ''
  153.     if isinstance(expr, ListRedirect):
  154.         expr = expr.reduce()
  155.     
  156.     if isinstance(expr, UnaryOperator):
  157.         return UnaryOperatorMapping[type(expr)] % mapToOperator(expr.argument, prolog, combinationArg)
  158.     if isinstance(expr, BinaryOperator):
  159.         return BinaryOperatorMapping[type(expr)] % (mapToOperator(expr.left, prolog, combinationArg), mapToOperator(expr.right, prolog, combinationArg), combinationInvokation)
  160.     if isinstance(expr, (Variable, Unbound)):
  161.         return '"%s"' % expr
  162.     if isinstance(expr, ParsedREGEXInvocation):
  163.         if not expr.arg3 or ',"' + expr.arg3 + '"':
  164.             pass
  165.         return 'sparqlOperators.regex(%s,%s%s)%s' % (mapToOperator(expr.arg1, prolog, combinationArg), mapToOperator(expr.arg2, prolog, combinationArg), '', combinationInvokation)
  166.     if isinstance(expr, BuiltinFunctionCall):
  167.         normBuiltInName = FUNCTION_NAMES[expr.name].lower()
  168.         normBuiltInName = CAMEL_CASE_BUILTINS.get(normBuiltInName, 'sparqlOperators.' + normBuiltInName)
  169.         return ','.join % ([], []([ mapToOperator(i, prolog, combinationArg) for i in expr.arguments ]), combinationInvokation)
  170.     if isinstance(expr, Literal):
  171.         return str(expr)
  172.     if isinstance(expr, URIRef):
  173.         import warnings
  174.         warnings.warn('There is the possibility of __repr__ being deprecated in python3K', DeprecationWarning, stacklevel = 3)
  175.         return repr(expr)
  176.     if isinstance(expr, (QName, basestring)):
  177.         return "'%s'" % convertTerm(expr, prolog)
  178.     if isinstance(expr, ParsedAdditiveExpressionList):
  179.         return [] % []([ mapToOperator(item, prolog, combinationArg = 'i') for item in expr ], combinationArg)
  180.     if isinstance(expr, FunctionCall):
  181.         if fUri in XSDToPython:
  182.             return "sparqlOperators.XSDCast(%s,'%s')%s" % (mapToOperator(expr.arguments[0], prolog, combinationArg = 'i'), fUri, combinationInvokation)
  183.         raise Exception('Whats do i do with %s (a %s)?' % (expr, type(expr).__name__))
  184.     isinstance(expr, FunctionCall)
  185.     raise Exception('What do i do with %s (a %s)?' % (expr, type(expr).__name__))
  186.  
  187.  
  188. def createSPARQLPConstraint(filter, prolog):
  189.     '''
  190.     Takes an instance of either ParsedExpressionFilter or ParsedFunctionFilter
  191.     and converts it to a sparql-p operator by composing a python string of lambda functions and SPARQL operators
  192.     This string is then evaluated to return the actual function for sparql-p
  193.     '''
  194.     if not isinstance(filter.filter, ListRedirect) or filter.filter.reduce():
  195.         pass
  196.     reducedFilter = filter.filter
  197.     if isinstance(reducedFilter, ParsedConditionalAndExpressionList):
  198.         combinationLambda = [] % []([ '%s' % mapToOperator(expr, prolog, combinationArg = 'i') for expr in reducedFilter ])
  199.         if prolog.DEBUG:
  200.             print 'sparql-p operator(s): %s' % combinationLambda
  201.         
  202.         return eval(combinationLambda)
  203.     if isinstance(reducedFilter, ParsedRelationalExpressionList):
  204.         combinationLambda = [] % []([ '%s' % mapToOperator(expr, prolog, combinationArg = 'i') for expr in reducedFilter ])
  205.         return eval(combinationLambda)
  206.     if isinstance(reducedFilter, BuiltinFunctionCall):
  207.         rt = mapToOperator(reducedFilter, prolog)
  208.         if prolog.DEBUG:
  209.             print 'sparql-p operator(s): %s' % rt
  210.         
  211.         return eval(rt)
  212.     if isinstance(reducedFilter, (ParsedAdditiveExpressionList, UnaryOperator, FunctionCall)):
  213.         rt = 'lambda(i): %s' % mapToOperator(reducedFilter, prolog, combinationArg = 'i')
  214.         return eval(rt)
  215.     rt = mapToOperator(reducedFilter, prolog)
  216.     return eval(rt)
  217.  
  218.  
  219. def sparqlPSetup(groupGraphPattern, prolog):
  220.     '''
  221.     This core function takes Where Clause and two lists of rdflib.sparql.graphPattern.BasicGraphPatterns
  222.     (the main patterns - connected by UNION - and an optional patterns)
  223.     This is the core SELECT API of sparql-p
  224.     '''
  225.     basicGraphPatterns = []
  226.     patternList = []
  227.     (graphGraphPatterns, optionalGraphPatterns, alternativeGraphPatterns) = categorizeGroupGraphPattern(groupGraphPattern)
  228.     (globalTPs, globalConstraints) = reorderBasicGraphPattern(groupGraphPattern[0])
  229.     if alternativeGraphPatterns:
  230.         for alternativeGPBlock in alternativeGraphPatterns:
  231.             for alternativeGPs in alternativeGPBlock.nonTripleGraphPattern:
  232.                 (triples, constraints) = reorderBasicGraphPattern(alternativeGPs[0])
  233.                 constraints.extend(globalConstraints)
  234.                 alternativeGPInst = []([ t for t in unRollTripleItems(triples, prolog) ])
  235.                 []([ createSPARQLPConstraint(constr, prolog) for constr in constraints ])
  236.                 basicGraphPatterns.append(alternativeGPInst)
  237.             
  238.         
  239.     elif graphGraphPatterns:
  240.         (triples, constraints) = reorderBasicGraphPattern(graphGraphPatterns[0].nonTripleGraphPattern[0])
  241.         for t in unRollTripleItems(triples, prolog):
  242.             patternList.append(t)
  243.         
  244.         basicGraphPattern = BasicGraphPattern(patternList)
  245.         for constr in constraints:
  246.             basicGraphPattern.addConstraint(createSPARQLPConstraint(constr, prolog))
  247.         
  248.         basicGraphPatterns.append(basicGraphPattern)
  249.     else:
  250.         (triples, constraints) = reorderBasicGraphPattern(groupGraphPattern[0])
  251.         for t in unRollTripleItems(triples, prolog):
  252.             patternList.append(t)
  253.         
  254.         basicGraphPattern = BasicGraphPattern(patternList)
  255.         for constr in constraints:
  256.             basicGraphPattern.addConstraint(createSPARQLPConstraint(constr, prolog))
  257.         
  258.         basicGraphPatterns.append(basicGraphPattern)
  259.     rtOptionalGraphPatterns = []
  260.     for g in optionalGraphPatterns:
  261.         pass
  262.     
  263.     return (basicGraphPatterns, rtOptionalGraphPatterns)
  264.  
  265.  
  266. def isTriplePattern(nestedTriples):
  267.     '''
  268.     Determines (recursively) if the BasicGraphPattern contains any Triple Patterns
  269.     returning a boolean flag indicating if it does or not
  270.     '''
  271.     if isinstance(nestedTriples, list):
  272.         for i in nestedTriples:
  273.             if isTriplePattern(i):
  274.                 return True
  275.             return False
  276.         
  277.     elif isinstance(nestedTriples, ParsedConstrainedTriples):
  278.         if nestedTriples.triples:
  279.             return isTriplePattern(nestedTriples.triples)
  280.         return False
  281.     elif isinstance(nestedTriples, ParsedConstrainedTriples) and not (nestedTriples.triples):
  282.         return isTriplePattern(nestedTriples.triples)
  283.     return True
  284.  
  285.  
  286. def categorizeGroupGraphPattern(gGP):
  287.     '''
  288.     Breaks down a ParsedGroupGraphPattern into mutually exclusive sets of
  289.     ParsedGraphGraphPattern, ParsedOptionalGraphPattern, and ParsedAlternativeGraphPattern units
  290.     '''
  291.     if not isinstance(gGP, ParsedGroupGraphPattern):
  292.         raise AssertionError, '%s is not a ParsedGroupGraphPattern' % gGP
  293.     graphGraphPatterns = _[1]
  294.     optionalGraphPatterns = _[2]
  295.     alternativeGraphPatterns = _[3]
  296.     return (graphGraphPatterns, optionalGraphPatterns, alternativeGraphPatterns)
  297.  
  298.  
  299. def validateGroupGraphPattern(gGP, noNesting = False):
  300.     '''
  301.     Verifies (recursively) that the Group Graph Pattern is supported
  302.     '''
  303.     firstGP = gGP[0]
  304.     (graphGraphPatternNo, optionalGraphPatternNo, alternativeGraphPatternNo) = [ len(gGPKlass) for gGPKlass in categorizeGroupGraphPattern(gGP) ]
  305.     if firstGP.triples and isTriplePattern(firstGP.triples) and isinstance(firstGP.nonTripleGraphPattern, ParsedAlternativeGraphPattern):
  306.         raise NotImplemented(UNION_GRAPH_PATTERN_NOT_SUPPORTED, '%s' % firstGP)
  307.     isinstance(firstGP.nonTripleGraphPattern, ParsedAlternativeGraphPattern)
  308.     if (graphGraphPatternNo > 1 or graphGraphPatternNo) and alternativeGraphPatternNo:
  309.         raise NotImplemented(GRAPH_GRAPH_PATTERN_NOT_SUPPORTED, '%s' % gGP)
  310.     alternativeGraphPatternNo
  311.     for gP in gGP:
  312.         if noNesting and isinstance(gP.nonTripleGraphPattern, (ParsedOptionalGraphPattern, ParsedGraphGraphPattern, ParsedAlternativeGraphPattern)):
  313.             raise NotImplemented(GROUP_GRAPH_PATTERN_NESTING_NOT_SUPPORTED, '%s' % gGP)
  314.         isinstance(gP.nonTripleGraphPattern, (ParsedOptionalGraphPattern, ParsedGraphGraphPattern, ParsedAlternativeGraphPattern))
  315.         if isinstance(gP.nonTripleGraphPattern, ParsedAlternativeGraphPattern):
  316.             for _gGP in gP.nonTripleGraphPattern:
  317.                 validateGroupGraphPattern(_gGP, noNesting = True)
  318.             
  319.         []
  320.         if gP.nonTripleGraphPattern:
  321.             validateGroupGraphPattern(gP.nonTripleGraphPattern, noNesting = True)
  322.             continue
  323.         []
  324.     
  325.  
  326.  
  327. def Evaluate(graph, query, passedBindings = { }, DEBUG = False):
  328.     '''
  329.     Takes:
  330.         1. a rdflib.Graph.Graph instance 
  331.         2. a SPARQL query instance (parsed using the BisonGen parser)
  332.         3. A dictionary of initial variable bindings (varName -> .. rdflib Term .. )
  333.         4. DEBUG Flag
  334.  
  335.     Returns a list of tuples - each a binding of the selected variables in query order
  336.     '''
  337.     if query.prolog:
  338.         query.prolog.DEBUG = DEBUG
  339.     
  340.     if query.query.dataSets:
  341.         graphs = []
  342.         for dtSet in query.query.dataSets:
  343.             if isinstance(dtSet, NamedGraph):
  344.                 graphs.append(Graph(graph.store, dtSet))
  345.                 continue
  346.             memStore = plugin.get('IOMemory', Store)()
  347.             memGraph = Graph(memStore)
  348.             
  349.             try:
  350.                 memGraph.parse(dtSet, format = 'n3')
  351.             except:
  352.                 memGraph.parse(dtSet)
  353.  
  354.             graphs.append(memGraph)
  355.         
  356.         tripleStore = sparqlGraph.SPARQLGraph(ReadOnlyGraphAggregate(graphs))
  357.     else:
  358.         tripleStore = sparqlGraph.SPARQLGraph(graph)
  359.     graphGraphPatterns = categorizeGroupGraphPattern(query.query.whereClause.parsedGraphPattern)[0]
  360.     gp = reorderGroupGraphPattern(query.query.whereClause.parsedGraphPattern)
  361.     validateGroupGraphPattern(gp)
  362.     (basicPatterns, optionalPatterns) = sparqlPSetup(gp, query.prolog)
  363.     result = queryObject(tripleStore, basicPatterns, optionalPatterns, passedBindings)
  364.     if result == None:
  365.         msg = 'Errors in the patterns, no valid query object generated; '
  366.         msg += 'pattern:\n%s\netc...' % basicPatterns[0]
  367.         raise SPARQLError(msg)
  368.     result == None
  369.     if isinstance(query.query, AskQuery):
  370.         return result.ask()
  371.     if isinstance(query.query, SelectQuery):
  372.         orderBy = None
  373.         orderAsc = None
  374.         if not query.query.solutionModifier.limitClause or int(query.query.solutionModifier.limitClause):
  375.             pass
  376.         limit = None
  377.         if not query.query.solutionModifier.offsetClause or int(query.query.solutionModifier.offsetClause):
  378.             pass
  379.         offset = 0
  380.         return (result.select(query.query.variables, query.query.distinct, limit, orderBy, orderAsc, offset), _variablesToArray(query.query.variables, 'selection'), result._getAllVariables(), orderBy, query.query.distinct)
  381.     raise NotImplemented(CONSTRUCT_NOT_SUPPORTED, repr(query))
  382.  
  383. OPTIONALS_NOT_SUPPORTED = 1
  384. UNION_GRAPH_PATTERN_NOT_SUPPORTED = 3
  385. GRAPH_GRAPH_PATTERN_NOT_SUPPORTED = 4
  386. GROUP_GRAPH_PATTERN_NESTING_NOT_SUPPORTED = 5
  387. CONSTRUCT_NOT_SUPPORTED = 6
  388. ExceptionMessages = {
  389.     OPTIONALS_NOT_SUPPORTED: 'Nested OPTIONAL not currently supported',
  390.     UNION_GRAPH_PATTERN_NOT_SUPPORTED: 'UNION Graph Pattern (currently) can only be combined with OPTIONAL Graph Patterns',
  391.     GRAPH_GRAPH_PATTERN_NOT_SUPPORTED: 'Graph Graph Pattern (currently) cannot only be used once by themselves or with OPTIONAL Graph Patterns',
  392.     GROUP_GRAPH_PATTERN_NESTING_NOT_SUPPORTED: 'Nesting of Group Graph Pattern (currently) not supported',
  393.     CONSTRUCT_NOT_SUPPORTED: '"Construct" is not (currently) supported' }
  394.  
  395. class NotImplemented(Exception):
  396.     
  397.     def __init__(self, code, msg):
  398.         self.code = code
  399.         self.msg = msg
  400.  
  401.     
  402.     def __str__(self):
  403.         return ExceptionMessages[self.code] + ' :' + self.msg
  404.  
  405.  
  406.